﻿/* Copyright (c) 2001-2009, The HSQL Development Group
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * Redistributions of source code must retain the above copyright notice, this
 * list of conditions and the following disclaimer.
 *
 * Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * Neither the name of the HSQL Development Group nor the names of its
 * contributors may be used to endorse or promote products derived from this
 * software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG,
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using EffiProz.Core.Rights;
using EffiProz.Core.Lib;

namespace EffiProz.Core.DataTypes
{
    public class Charset : SchemaObject
    {

        public static int[][] uppercaseLetters = new int[][] {
        new int[]{
            'A', 'Z'
        }
    };
        public static int[][] unquotedIdentifier = new int[][] {
        new int[]{
            '0', '9'
        }, new int[]{
            'A', 'Z'
        },new int[]{
            '_', '_'
        }
    };
        public static int[][] basicIdentifier = new int[][] {
        new int[]{
            '0', '9'
        }, new int[]{
            'A', 'Z'
        }, new int[]{
            '_', '_'
        }, new int[]{
            'a', 'z'
        }
    };

        public QNameManager.QName name;
        public QNameManager.QName _base;

        //
        public int[][] ranges;

        public Charset(QNameManager.QName name)
        {
            this.name = name;
        }

        public virtual  int getType()
        {
            return SchemaObjectTypes.CHARSET;
        }

        public virtual QNameManager.QName getName()
        {
            return name;
        }

        public virtual  QNameManager.QName getCatalogName()
        {
            return name.schema.schema;
        }

        public virtual  QNameManager.QName getSchemaName()
        {
            return name.schema;
        }

        public virtual Grantee getOwner()
        {
            return name.schema.owner;
        }

        public virtual OrderedHashSet getReferences()
        {

            OrderedHashSet set = new OrderedHashSet();

            set.add(_base);

            return set;
        }

        public virtual OrderedHashSet getComponents()
        {
            return null;
        }

        public virtual void compile(Session session, SchemaObject parentObject) { }

        public virtual String getSQL()
        {

            StringBuilder sb = new StringBuilder();

            sb.Append(Tokens.T_CREATE).Append(' ').Append(
                Tokens.T_CHARACTER).Append(' ').Append(Tokens.T_SET).Append(' ');
            sb.Append(name.getSchemaQualifiedStatementName());
            sb.Append(' ').Append(Tokens.T_AS).Append(' ').Append(Tokens.T_GET);
            sb.Append(' ').Append(_base.getSchemaQualifiedStatementName());

            return sb.ToString();
        }

        public static bool isInSet(String value, int[][] ranges)
        {

            int length = value.Length;


            for (int index = 0; index < length; index++)
            {
                int ch = value[index];

                for (int i = 0; i < ranges.GetLength(0); i++)
                {
                    if (ch > ranges[i][1])
                    {
                        continue;
                    }

                    if (ch < ranges[i][0])
                    {
                        return false;
                    }

                    goto mainLoop;
                }

                return false;
            mainLoop:
                continue;
            }

            return true;
        }

        public static bool startsWith(String value, int[][] ranges)
        {

            int ch = value[0];

            for (int i = 0; i < ranges.Length; i++)
            {
                if (ch > ranges[i][1])
                {
                    continue;
                }

                if (ch < ranges[i][0])
                {
                    return false;
                }

                return true;
            }

            return false;
        }

        public static Charset getDefaultInstance()
        {

            return SqlInvariants.UTF8;
        }
    }
}
